package com.aiguigu.lottery.user.service.impl;

import com.aiguigu.lottery.common.entity.UserEntity;
import com.aiguigu.lottery.common.vo.LoginResponse;
import com.aiguigu.lottery.common.utils.JwtUtils;
import com.aiguigu.lottery.common.utils.PasswordUtils;
import com.aiguigu.lottery.user.mapper.UserMapper;
import com.aiguigu.lottery.user.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * 用户服务实现类
 */
@Service
public class UserServiceImpl implements UserService {
    
    private static final Logger logger = LoggerFactory.getLogger(UserServiceImpl.class);
    
    @Autowired
    private UserMapper userMapper;
    
    @Autowired
    private JwtUtils jwtUtils;
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    @Override
    public LoginResponse login(String username, String password) {
        try {
            UserEntity user = userMapper.findByUsername(username);
            
            if (user != null && PasswordUtils.verifyPassword(password, user.getPassword())) {
                String token = jwtUtils.generateToken(username, user.getUserType(), user.getId().longValue());
                
                // 将token存储到Redis中，设置过期时间
                redisTemplate.opsForValue().set("token:" + username, token, 24, TimeUnit.HOURS);
                
                return new LoginResponse(token, username, user.getUserType(), user.getId().longValue());
            }
            
            return null;
        } catch (Exception e) {
            logger.error("登录失败", e);
            throw new RuntimeException("登录失败", e);
        }
    }
    
    @Override
    public boolean register(UserEntity user) {
        try {
            // 检查用户名是否已存在
            UserEntity existingUser = userMapper.findByUsername(user.getUsername());
            if (existingUser != null) {
                return false;
            }
            
            // 验证密码强度
            if (!PasswordUtils.isPasswordStrong(user.getPassword())) {
                logger.warn("密码强度不符合要求: {}", user.getUsername());
                throw new RuntimeException("密码必须至少6位，且包含字母和数字");
            }
            
            // 加密密码
            String encryptedPassword = PasswordUtils.encryptPassword(user.getPassword());
            user.setPassword(encryptedPassword);
            
            // 设置默认值
            user.setCreateTime(new Date());
            user.setUpdateTime(new Date());
            
            // 设置默认职位为学生
            if (user.getJob() == null) {
                user.setJob(4); // 4表示学生
            }
            
            // 设置默认性别为男
            if (user.getGender() == null) {
                user.setGender(1); // 1表示男
            }
            
            // 设置默认姓名（如果没有提供）
            if (user.getName() == null || user.getName().trim().isEmpty()) {
                user.setName(user.getUsername()); // 使用用户名作为默认姓名
            }
            
            int result = userMapper.insert(user);
            return result > 0;
        } catch (Exception e) {
            logger.error("注册失败", e);
            throw new RuntimeException("注册失败", e);
        }
    }
    
    @Override
    public UserEntity getUserById(Long userId) {
        try {
            return userMapper.findById(userId.intValue());
        } catch (Exception e) {
            logger.error("获取用户信息失败", e);
            throw new RuntimeException("获取用户信息失败", e);
        }
    }
    
    @Override
    public UserEntity getUserById(Integer userId) {
        try {
            return userMapper.findById(userId);
        } catch (Exception e) {
            logger.error("获取用户信息失败", e);
            throw new RuntimeException("获取用户信息失败", e);
        }
    }
    
    @Override
    public UserEntity getUserByUsername(String username) {
        try {
            return userMapper.findByUsername(username);
        } catch (Exception e) {
            logger.error("获取用户信息失败", e);
            throw new RuntimeException("获取用户信息失败", e);
        }
    }
    
    @Override
    public java.util.List<UserEntity> getAllUsers() {
        try {
            return userMapper.findAll();
        } catch (Exception e) {
            logger.error("获取用户列表失败", e);
            throw new RuntimeException("获取用户列表失败", e);
        }
    }
    
    @Override
    public boolean updateUserProfile(UserEntity user) {
        try {
            // 设置更新时间
            user.setUpdateTime(new Date());
            
            int result = userMapper.updateProfile(user);
            return result > 0;
        } catch (Exception e) {
            logger.error("更新用户个人信息失败", e);
            throw new RuntimeException("更新用户个人信息失败", e);
        }
    }
    
    @Override
    @Transactional
    public boolean deleteUser(Integer userId) {
        logger.info("开始删除用户，用户ID: {}", userId);
        try {
            // 先删除用户相关的中奖记录（处理外键约束）
            logger.info("准备删除用户ID {} 的中奖记录", userId);
            int deletedRecords = userMapper.deletePrizeRecordsByUserId(userId);
            logger.info("删除用户ID {} 的中奖记录 {} 条", userId, deletedRecords);
            
            // 再删除用户
            logger.info("准备删除用户ID {}", userId);
            int result = userMapper.deleteById(userId);
            logger.info("删除用户操作结果: {}", result);
            
            if (result > 0) {
                logger.info("用户ID {} 删除成功", userId);
                return true;
            } else {
                logger.warn("用户ID {} 删除失败，可能不存在", userId);
                return false;
            }
        } catch (Exception e) {
            logger.error("删除用户失败，用户ID: {}, 错误类型: {}, 错误信息: {}", userId, e.getClass().getSimpleName(), e.getMessage(), e);
            // 抛出异常让Controller的catch块处理
            throw new RuntimeException("删除用户时发生错误: " + e.getMessage(), e);
        }
    }
}